/**
 * 校园二手交易平台 - 分类数据模型
 * 为校园二手交易平台设计的分类相关数据类型定义
 */

import { ProductCategory } from './product';

/**
 * 分类层级枚举
 */
export enum CategoryLevel {
  /** 一级分类 */
  LEVEL_1 = 1,
  /** 二级分类 */
  LEVEL_2 = 2,
  /** 三级分类 */
  LEVEL_3 = 3
}

/**
 * 分类状态枚举
 */
export enum CategoryStatus {
  /** 启用 */
  ENABLED = 'enabled',
  /** 禁用 */
  DISABLED = 'disabled',
  /** 隐藏 */
  HIDDEN = 'hidden'
}

/**
 * 分类显示类型枚举
 */
export enum CategoryDisplayType {
  /** 图标形式 */
  ICON = 'icon',
  /** 列表形式 */
  LIST = 'list',
  /** 网格形式 */
  GRID = 'grid',
  /** 树形结构 */
  TREE = 'tree'
}

/**
 * 分类基础信息
 */
export interface CategoryBaseInfo {
  /** 分类ID */
  id: string;
  /** 分类名称 */
  name: string;
  /** 分类代码（英文标识） */
  code: string;
  /** 分类描述 */
  description?: string;
  /** 分类层级 */
  level: CategoryLevel;
  /** 排序序号 */
  sortOrder: number;
  /** 分类状态 */
  status: CategoryStatus;
  /** 创建时间 */
  createdAt: Date;
  /** 更新时间 */
  updatedAt: Date;
}

/**
 * 分类显示信息
 */
export interface CategoryDisplayInfo {
  /** 图标URL */
  iconUrl?: string;
  /** 背景图片URL */
  backgroundImageUrl?: string;
  /** 主题颜色 */
  themeColor?: string;
  /** 显示类型 */
  displayType: CategoryDisplayType;
  /** 是否在首页显示 */
  showInHomepage: boolean;
  /** 是否在导航栏显示 */
  showInNavigation: boolean;
  /** 是否推荐 */
  isRecommended: boolean;
  /** 显示顺序 */
  displayOrder: number;
}

/**
 * 分类统计信息
 */
export interface CategoryStats {
  /** 商品总数 */
  totalProducts: number;
  /** 上架商品数 */
  activeProducts: number;
  /** 今日新增商品数 */
  todayNewProducts: number;
  /** 平均价格 */
  averagePrice: number;
  /** 最高价格 */
  maxPrice: number;
  /** 最低价格 */
  minPrice: number;
  /** 交易成功率 */
  transactionSuccessRate: number;
  /** 商品活跃度（基于浏览量、收藏量等计算） */
  activityScore: number;
}

/**
 * 分类属性筛选条件
 */
export interface CategoryFilterAttribute {
  /** 属性ID */
  id: string;
  /** 属性名称 */
  name: string;
  /** 属性代码 */
  code: string;
  /** 属性类型（文本、数字、枚举、布尔等） */
  type: 'text' | 'number' | 'enum' | 'boolean' | 'range';
  /** 属性值选项（如果是枚举类型） */
  options?: Array<{
    value: string;
    label: string;
    count?: number;
  }>;
  /** 是否多选 */
  multiple: boolean;
  /** 是否必填 */
  required: boolean;
  /** 排序序号 */
  sortOrder: number;
  /** 是否显示在筛选面板 */
  showInFilter: boolean;
  /** 是否支持搜索 */
  searchable: boolean;
}

/**
 * 完整分类信息
 */
export interface Category extends CategoryBaseInfo, CategoryDisplayInfo {
  /** 父分类ID（如果是一级分类则为null） */
  parentId: string | null;
  /** 完整路径（从根分类到当前分类的路径） */
  path: string[];
  /** 完整路径名称 */
  pathNames: string[];
  /** 子分类列表 */
  children: Category[];
  /** 统计信息 */
  stats: CategoryStats;
  /** 筛选属性 */
  filterAttributes: CategoryFilterAttribute[];
  /** 相关标签 */
  tags: string[];
  /** 是否叶子节点 */
  isLeaf: boolean;
  /** 分类深度 */
  depth: number;
}

/**
 * 分类树节点
 */
export interface CategoryTreeNode {
  /** 分类信息 */
  category: Category;
  /** 子节点 */
  children: CategoryTreeNode[];
  /** 是否展开 */
  expanded?: boolean;
  /** 是否选中 */
  selected?: boolean;
  /** 是否部分选中（用于多选） */
  partiallySelected?: boolean;
}

/**
 * 分类创建/编辑表单数据
 */
export interface CategoryFormData {
  /** 分类名称 */
  name: string;
  /** 分类代码 */
  code: string;
  /** 分类描述 */
  description?: string;
  /** 父分类ID */
  parentId?: string | null;
  /** 排序序号 */
  sortOrder: number;
  /** 分类状态 */
  status: CategoryStatus;
  /** 图标URL */
  iconUrl?: string;
  /** 背景图片URL */
  backgroundImageUrl?: string;
  /** 主题颜色 */
  themeColor?: string;
  /** 显示类型 */
  displayType: CategoryDisplayType;
  /** 是否在首页显示 */
  showInHomepage: boolean;
  /** 是否在导航栏显示 */
  showInNavigation: boolean;
  /** 是否推荐 */
  isRecommended: boolean;
  /** 显示顺序 */
  displayOrder: number;
  /** 标签列表 */
  tags?: string[];
}

/**
 * 分类查询参数
 */
export interface CategoryQueryParams {
  /** 分类名称关键词 */
  keyword?: string;
  /** 父分类ID */
  parentId?: string | null;
  /** 分类层级 */
  level?: CategoryLevel;
  /** 分类状态 */
  status?: CategoryStatus;
  /** 是否只显示叶子节点 */
  onlyLeaf?: boolean;
  /** 是否包含统计信息 */
  includeStats?: boolean;
  /** 是否包含子分类 */
  includeChildren?: boolean;
  /** 是否包含筛选属性 */
  includeFilters?: boolean;
  /** 页码 */
  page?: number;
  /** 每页数量 */
  pageSize?: number;
  /** 排序字段 */
  sortBy?: 'name' | 'sortOrder' | 'createdAt' | 'updatedAt' | 'totalProducts';
  /** 排序方向 */
  sortOrder?: 'asc' | 'desc';
}

/**
 * 分类列表响应数据
 */
export interface CategoryListResponse {
  /** 分类列表 */
  categories: Category[];
  /** 总数量 */
  total: number;
  /** 当前页码 */
  currentPage: number;
  /** 总页数 */
  totalPages: number;
  /** 每页数量 */
  pageSize: number;
  /** 分类树结构 */
  tree?: CategoryTreeNode;
}

/**
 * 分类操作结果
 */
export interface CategoryOperationResult {
  /** 操作是否成功 */
  success: boolean;
  /** 操作结果消息 */
  message: string;
  /** 操作后的分类数据 */
  category?: Category;
  /** 错误信息（如果操作失败） */
  error?: string;
  /** 警告信息 */
  warnings?: string[];
}

/**
 * 分类批量操作参数
 */
export interface CategoryBatchOperationParams {
  /** 分类ID列表 */
  categoryIds: string[];
  /** 操作类型 */
  operation: 'enable' | 'disable' | 'delete' | 'move' | 'updateSort';
  /** 目标父分类ID（用于移动操作） */
  targetParentId?: string;
  /** 新的排序序号（用于排序操作） */
  newSortOrder?: number;
  /** 批量更新数据 */
  updateData?: Partial<CategoryFormData>;
}

/**
 * 分类导入导出数据
 */
export interface CategoryImportExportData {
  /** 分类数据 */
  categories: Array<{
    name: string;
    code: string;
    description?: string;
    parentCode?: string; // 父分类代码
    sortOrder: number;
    status: CategoryStatus;
    iconUrl?: string;
    displayType: CategoryDisplayType;
    showInHomepage: boolean;
    showInNavigation: boolean;
    isRecommended: boolean;
    displayOrder: number;
    tags?: string[];
  }>;
  /** 导入导出时间 */
  timestamp: Date;
  /** 版本信息 */
  version: string;
}

/**
 * 分类推荐配置
 */
export interface CategoryRecommendationConfig {
  /** 是否启用推荐 */
  enabled: boolean;
  /** 推荐算法类型 */
  algorithm: 'popularity' | 'recency' | 'trending' | 'personalized';
  /** 推荐数量 */
  recommendationCount: number;
  /** 基于用户行为的推荐权重 */
  userBehaviorWeight: number;
  /** 基于商品属性的推荐权重 */
  productAttributeWeight: number;
  /** 基于分类关系的推荐权重 */
  categoryRelationWeight: number;
  /** 更新时间间隔（小时） */
  updateInterval: number;
}

/**
 * 分类统计报告
 */
export interface CategoryReport {
  /** 报告ID */
  id: string;
  /** 报告名称 */
  name: string;
  /** 报告时间范围 */
  timeRange: {
    start: Date;
    end: Date;
  };
  /** 分类统计概览 */
  overview: {
    totalCategories: number;
    activeCategories: number;
    totalProducts: number;
    averageProductsPerCategory: number;
    mostPopularCategory: string;
    fastestGrowingCategory: string;
  };
  /** 详细统计数据 */
  detailedStats: Array<{
    category: Category;
    stats: CategoryStats;
    growthRate: number; // 增长率
    trend: 'up' | 'down' | 'stable'; // 趋势
  }>;
  /** 生成时间 */
  generatedAt: Date;
}

/**
 * 默认分类查询参数
 */
export const DEFAULT_CATEGORY_QUERY_PARAMS: CategoryQueryParams = {
  page: 1,
  pageSize: 50,
  status: CategoryStatus.ENABLED,
  includeStats: true,
  includeChildren: true,
  sortBy: 'sortOrder',
  sortOrder: 'asc'
};

/**
 * 分类层级显示名称映射
 */
export const CATEGORY_LEVEL_DISPLAY_NAMES: Record<CategoryLevel, string> = {
  [CategoryLevel.LEVEL_1]: '一级分类',
  [CategoryLevel.LEVEL_2]: '二级分类',
  [CategoryLevel.LEVEL_3]: '三级分类'
};

/**
 * 分类状态显示名称映射
 */
export const CATEGORY_STATUS_DISPLAY_NAMES: Record<CategoryStatus, string> = {
  [CategoryStatus.ENABLED]: '启用',
  [CategoryStatus.DISABLED]: '禁用',
  [CategoryStatus.HIDDEN]: '隐藏'
};

/**
 * 分类显示类型显示名称映射
 */
export const CATEGORY_DISPLAY_TYPE_DISPLAY_NAMES: Record<CategoryDisplayType, string> = {
  [CategoryDisplayType.ICON]: '图标形式',
  [CategoryDisplayType.LIST]: '列表形式',
  [CategoryDisplayType.GRID]: '网格形式',
  [CategoryDisplayType.TREE]: '树形结构'
};

/**
 * 工具函数：验证分类数据
 */
export const validateCategoryData = (category: Partial<Category>): boolean => {
  if (!category.name || category.name.trim().length === 0) {
    return false;
  }
  if (!category.code || category.code.trim().length === 0) {
    return false;
  }
  if (!category.level || !Object.values(CategoryLevel).includes(category.level)) {
    return false;
  }
  if (category.sortOrder === undefined || category.sortOrder < 0) {
    return false;
  }
  if (!category.status || !Object.values(CategoryStatus).includes(category.status)) {
    return false;
  }
  return true;
};

/**
 * 工具函数：生成分类路径
 */
export const generateCategoryPath = (category: Category, allCategories: Category[]): string[] => {
  const path: string[] = [category.id];
  let currentCategory = category;
  
  while (currentCategory.parentId) {
    const parent = allCategories.find(cat => cat.id === currentCategory.parentId);
    if (parent) {
      path.unshift(parent.id);
      currentCategory = parent;
    } else {
      break;
    }
  }
  
  return path;
};

/**
 * 工具函数：生成分类路径名称
 */
export const generateCategoryPathNames = (category: Category, allCategories: Category[]): string[] => {
  const pathNames: string[] = [category.name];
  let currentCategory = category;
  
  while (currentCategory.parentId) {
    const parent = allCategories.find(cat => cat.id === currentCategory.parentId);
    if (parent) {
      pathNames.unshift(parent.name);
      currentCategory = parent;
    } else {
      break;
    }
  }
  
  return pathNames;
};

/**
 * 工具函数：检查分类是否可以删除
 */
export const canDeleteCategory = (category: Category): boolean => {
  // 如果分类下有商品，不能删除
  if (category.stats.totalProducts > 0) {
    return false;
  }
  
  // 如果分类下有子分类，不能删除
  if (category.children.length > 0) {
    return false;
  }
  
  return true;
};

/**
 * 工具函数：构建分类树
 */
export const buildCategoryTree = (categories: Category[]): CategoryTreeNode[] => {
  const categoryMap = new Map<string, CategoryTreeNode>();
  const rootNodes: CategoryTreeNode[] = [];
  
  // 首先创建所有节点的映射
  categories.forEach(category => {
    categoryMap.set(category.id, {
      category,
      children: []
    });
  });
  
  // 然后构建树结构
  categories.forEach(category => {
    const node = categoryMap.get(category.id)!;
    
    if (category.parentId) {
      const parentNode = categoryMap.get(category.parentId);
      if (parentNode) {
        parentNode.children.push(node);
      } else {
        // 如果父节点不存在，将其作为根节点
        rootNodes.push(node);
      }
    } else {
      // 没有父节点，作为根节点
      rootNodes.push(node);
    }
  });
  
  return rootNodes;
};

/**
 * 工具函数：扁平化分类树
 */
export const flattenCategoryTree = (treeNodes: CategoryTreeNode[]): Category[] => {
  const categories: Category[] = [];
  
  const traverse = (nodes: CategoryTreeNode[]) => {
    nodes.forEach(node => {
      categories.push(node.category);
      if (node.children.length > 0) {
        traverse(node.children);
      }
    });
  };
  
  traverse(treeNodes);
  return categories;
};

/**
 * 工具函数：查找分类路径
 */
export const findCategoryPath = (categoryId: string, categories: Category[]): Category[] => {
  const path: Category[] = [];
  const categoryMap = new Map(categories.map(cat => [cat.id, cat]));
  
  let currentId = categoryId;
  while (currentId) {
    const category = categoryMap.get(currentId);
    if (category) {
      path.unshift(category);
      currentId = category.parentId || '';
    } else {
      break;
    }
  }
  
  return path;
};

/**
 * 工具函数：获取所有子分类ID
 */
export const getAllChildCategoryIds = (categoryId: string, categories: Category[]): string[] => {
  const childIds: string[] = [];
  
  const findChildren = (parentId: string) => {
    const children = categories.filter(cat => cat.parentId === parentId);
    children.forEach(child => {
      childIds.push(child.id);
      findChildren(child.id);
    });
  };
  
  findChildren(categoryId);
  return childIds;
};

/**
 * 工具函数：分类搜索（支持模糊匹配）
 */
export const searchCategories = (categories: Category[], keyword: string): Category[] => {
  if (!keyword.trim()) {
    return categories;
  }
  
  const lowerKeyword = keyword.toLowerCase();
  return categories.filter(category => 
    category.name.toLowerCase().includes(lowerKeyword) ||
    category.code.toLowerCase().includes(lowerKeyword) ||
    (category.description && category.description.toLowerCase().includes(lowerKeyword)) ||
    category.tags.some(tag => tag.toLowerCase().includes(lowerKeyword))
  );
};

/**
 * 工具函数：计算分类活跃度分数
 */
export const calculateCategoryActivityScore = (stats: CategoryStats): number => {
  // 基于商品数量、浏览量、收藏量等计算活跃度
  const productCountWeight = 0.3;
  const viewCountWeight = 0.3;
  const favoriteCountWeight = 0.2;
  const transactionRateWeight = 0.2;
  
  // 这里使用简化的计算方法，实际项目中可能需要更复杂的算法
  const score = (
    (stats.activeProducts * productCountWeight) +
    (stats.activityScore * viewCountWeight) +
    (stats.transactionSuccessRate * transactionRateWeight)
  );
  
  return Math.min(score, 100); // 限制在0-100分之间
};

/**
 * 预定义分类模板（用于快速初始化）
 */
export const CATEGORY_TEMPLATES: Record<string, Partial<CategoryFormData>> = {
  'textbooks': {
    name: '教材书籍',
    code: 'textbooks',
    description: '各类教材、参考书、学术书籍',
    sortOrder: 1,
    displayType: CategoryDisplayType.ICON,
    showInHomepage: true,
    showInNavigation: true,
    isRecommended: true,
    displayOrder: 1,
    tags: ['教材', '书籍', '参考书', '学术']
  },
  'electronics': {
    name: '电子产品',
    code: 'electronics',
    description: '手机、电脑、平板等电子产品',
    sortOrder: 2,
    displayType: CategoryDisplayType.ICON,
    showInHomepage: true,
    showInNavigation: true,
    isRecommended: true,
    displayOrder: 2,
    tags: ['手机', '电脑', '平板', '数码']
  },
  'clothing': {
    name: '服饰鞋包',
    code: 'clothing',
    description: '服装、鞋子、箱包等',
    sortOrder: 3,
    displayType: CategoryDisplayType.ICON,
    showInHomepage: true,
    showInNavigation: true,
    isRecommended: true,
    displayOrder: 3,
    tags: ['服装', '鞋子', '箱包', '配饰']
  }
};